home *** CD-ROM | disk | FTP | other *** search
/ Programmer Power Tools / Programmer Power Tools.iso / progjrn / pj_6_6.arc / DDI.C < prev    next >
C/C++ Source or Header  |  1988-10-18  |  11KB  |  494 lines
  1. /*
  2. * DDI - Device information program
  3. *
  4. * Written By:    Steve Rodgers
  5. * Conception:    5-4-86
  6. *
  7. * Copyright (C) 1987 Steve Rodgers
  8. *
  9. *
  10. * Functional Description
  11. * ----------------------
  12. *
  13. * This program displays information about installable device drivers
  14. * loaded under DOS 2.0 or later. If the command is typed without any
  15. * arguments, a summary will be printed which shows the order of the devices
  16. * in the chain. If a device name is typed following the command, detailed
  17. * information pertinent to that device will be displayed. This program
  18. * works with either character or block devices as arguments.
  19. *
  20. *
  21. * Revision History
  22. * ----------------
  23. *
  24. * First Release Version 0.1 released 5-7-86
  25. * Second Release Version 0.2 released 3-12-87
  26. * Third Release Version 1.0 released 2-18-88
  27. *
  28. * Compilation instructions
  29. * ------------------------
  30. *
  31. * Use the Microsoft C compiler version 3.00 or later.
  32. * Compile with the -Zp switch.
  33. * 
  34. * Dependencies
  35. * ------------
  36. *
  37. * This module requires the following include files:
  38. *
  39. * stdio.h 
  40. * dos.h    
  41. * string.h
  42. *
  43. *
  44. * Linking instructions
  45. * --------------------
  46. *
  47. * Use the Microsoft linker version 3.00 or later.
  48. *
  49. * LINK COMMAND LINE : link di;
  50. * 
  51. *
  52. *
  53. */
  54.  
  55. #include <stdio.h>
  56. #include <dos.h>
  57. #include <string.h>
  58.  
  59. /*
  60. * Device attribute definitions
  61. */
  62.  
  63. #define    CHARACTER_DEVICE    0x8000
  64. #define IOCTL_SUPPORT        0x4000
  65. #define NON_IBM_FORMAT        0x2000
  66. #define OPEN_CLOSE_SUPPORT    0x800
  67. #define    IS_CLOCK        8
  68. #define IS_NUL            4
  69. #define IS_STDIN        2
  70. #define IS_STDOUT        1
  71.  
  72. /*
  73. * Structure definitions
  74. *
  75. *
  76. * Device header
  77. */
  78.  
  79. struct DEV_HDR
  80.     {
  81.     struct DEV_HDR far    *next_hdr ;    /* pointer next device header */
  82.     unsigned int        attribute ;    /* attribute bits */
  83.     unsigned int        strategy ;    /* strategy offset */
  84.     unsigned int        interruptx ;    /* interrupt offset */
  85.     unsigned char        name[8] ;    /* device name */
  86.     } ;
  87.  
  88. /*
  89. * Disk Parameter Block - Returned by DOS function 32H
  90. */
  91.  
  92. struct DPB
  93.     {
  94.     unsigned char        ad ;        /* current assigned disk */
  95.     unsigned char        alt_ad ;    /* alternate assigned disk */
  96.     unsigned int        bps ;        /* bytes per sector */
  97.     unsigned char        last_sic ;    /* max sector addr in a cluster */
  98.     unsigned char        last_head ;    /* max useable head address */
  99.     unsigned int        rs ;        /* total reserved sectors */
  100.     unsigned char        cf ;        /* copies of the FAT */
  101.     unsigned int        d ;        /* max root directory entries */
  102.     unsigned int        fus ;        /* first useable sector */
  103.     unsigned int        tccplusone ;    /* total clusters available + 1 */
  104.     unsigned char        spf ;        /* sectors per FAT */
  105.     unsigned int        fds ;        /* first directory sector */
  106.     struct DEV_HDR far    *dda ;        /* device driver address */
  107.     unsigned char        md ;        /* media discriptor */
  108.     struct DISK_DPB far    *next_dpb ;    /* address of next dpb in chain */
  109.     unsigned int        cwd_cluster ;     /* cluster of CWD (DOS 2.x only) */
  110.     unsigned char        cwd_string[64] ; /* CWD string (DOS 2.x only) */
  111.     } ;
  112.  
  113. /*
  114. * Function declarations
  115. */
  116.  
  117. struct DPB far *disk_dpb() ;
  118. struct DEV_HDR far *device_chain() ;
  119.  
  120. /*
  121. * Static Declarations
  122. */
  123.  
  124. union REGS ir,or ;
  125. struct SREGS sr ;
  126.  
  127. int is_disk = 0 ;
  128.  
  129. /*
  130. * Attribute bit table
  131. */
  132.  
  133. int attr_bit_masks[] = {CHARACTER_DEVICE,IOCTL_SUPPORT,NON_IBM_FORMAT,
  134.             OPEN_CLOSE_SUPPORT,IS_CLOCK,IS_NUL,IS_STDIN,IS_STDOUT};
  135.  
  136. /*
  137. * Global pointer variables 
  138. */
  139.  
  140. struct DEV_HDR far *current_device, far *previous_device ;
  141. struct DPB far *current_dpb ;
  142.  
  143. /*
  144. * Global device type counters
  145. */
  146.  
  147. int block_drivers = 0,character_drivers = 0 ;
  148.  
  149. /*
  150. * Function: main()
  151. */
  152.  
  153. main(argc,argv)
  154. int argc ;
  155. char *argv[] ;
  156. {
  157.     int i ;
  158.     char *device_name ;
  159.  
  160.     printf("\nDDI   -              Device Driver Information Program\n") ;
  161.     printf("Version 1.0 (2-18-88) Copyright (C) 1988 Steve Rodgers\n\n") ;
  162.  
  163.     if(argc < 2) /* if no argument, print the device list */ 
  164.     {
  165.         list_devices() ;
  166.         exit(0) ;
  167.     }
  168.  
  169.     if((device_name = strupr(strdup(argv[1]))) == NULL)
  170.         abort() ;
  171.     print_single_device(device_name) ;
  172. }
  173.  
  174. /*
  175. * Function: print_single_device() 
  176. *
  177. * Print information for a single device.
  178. */
  179.  
  180. print_single_device(device_name)
  181. char device_name[] ;
  182. { 
  183.     int i ;
  184.  
  185. /*
  186. *
  187. * Function: get_device() ;
  188. *
  189. * Get pointer for a specific device.
  190. * If it doesn't exist print an error message.
  191. */
  192.  
  193.     get_device(device_name) ;
  194.     if(current_device == NULL)
  195.     {
  196.         printf("No such device: %s\n",device_name) ;
  197.         exit(1) ;
  198.     }
  199.  
  200. /*
  201. * Print the device address, type, and name.
  202. */
  203.  
  204.     print_device_columns() ;
  205.     print_device_info(current_device) ;
  206.  
  207. /*
  208. * Print the detailed information for the device
  209. */
  210.  
  211.     printf("\n") ;
  212.     printf("                          A T T R I B U T E S\n") ;
  213.     printf("------------------------------------------------------------------------\n") ;
  214.     printf("| CHAR   | IOCTL  | NONIBM | OPNCLS | STDCLK | NULDEV | STDOUT | STDIN |\n") ;
  215.     for(i = 0 ; i < 8 ; i++)
  216.     {
  217.         printf("   ") ;
  218.         if((attr_bit_masks[i] & current_device->attribute))
  219.             printf("yes   ") ;
  220.         else
  221.             printf("no    ") ;
  222.     }
  223.     printf("\n\n") ;
  224.     printf("Strategy entry point\t\t: %04X:%04X\n",
  225.             FP_SEG(current_device),
  226.             current_device->strategy) ;
  227.     
  228.     printf("Interrupt entry point\t\t: %04X:%04X\n",
  229.             FP_SEG(current_device),
  230.             current_device->interruptx) ;
  231.  
  232. /*
  233. * Return to DOS
  234. */
  235.  
  236.     exit(0) ;
  237. }
  238.  
  239. /*
  240. * Function: list_devices()
  241. *
  242. * Print a summary of all devices in the chain.
  243. */
  244.  
  245. list_devices()
  246. {
  247.  
  248. /*
  249. * Get the head of the device list.
  250. * If this isn't possible, print an error message and exit
  251. */
  252.  
  253.     if((current_device = device_chain()) == NULL)
  254.         no_device_chain() ;
  255.  
  256. /*
  257. * Print the column information
  258. */
  259.  
  260.     print_device_columns() ;
  261.  
  262. /*
  263. * Follow the chain until a -1 is reached
  264. */
  265.  
  266.     while(FP_OFF(current_device) != -1)
  267.     {
  268.         print_device_info(current_device) ;
  269.         current_device = current_device->next_hdr ;
  270.     }
  271.     printf("\nSystem has %d character drivers, and %d block drivers\n",
  272.         character_drivers,block_drivers) ;
  273. }
  274.  
  275. /*
  276. * Function: get_device()
  277. *
  278. * Find character or block device driver.
  279. * Fill in current device pointer, previous device pointer, and
  280. * current DPB if block device.
  281. *
  282. */
  283.  
  284. get_device(d)
  285. char d[] ;
  286. {
  287.     int i ;
  288.     char device_string[9] ;
  289.  
  290.     current_device = NULL ;
  291.     current_dpb = NULL ;
  292.     if(strlen(d) > 8)
  293.         return ;
  294.  
  295. /*
  296. * If there is a colon in the second character position, user
  297. * is requesting information about a block device.
  298. */
  299.  
  300.     if(d[1] != ':')
  301.     { 
  302.  
  303. /*
  304. * The name specified is probably a character device.
  305. * If a colon follows the device name, delete it from the string. 
  306. */
  307.  
  308.         if(d[strlen(d) - 1] == ':') /* kill colon at end of device name */
  309.             d[strlen(d) - 1] = 0 ;
  310. /*
  311. * Attempt to get the pointer to the first device in the chain.
  312. * if it comes back NULL, the user probably did not install the
  313. * trace device driver.
  314. */
  315.  
  316.         if((current_device = device_chain()) == NULL)
  317.             no_device_chain() ;  /* no device chain available */
  318.  
  319. /*
  320. * Trace the device chain until device name matches a
  321. * device in the chain
  322. */
  323.  
  324.         while(FP_OFF(current_device) != -1)
  325.         {
  326.             for(i = 0 ; i < 8 ; i++)
  327.                 device_string[i] = current_device->name[i] ;
  328.             device_string[8] = 0 ;
  329.             if(!strncmp(device_string,d,strlen(d)))
  330.                 if((strlen(d) == 8) ||
  331.                     (current_device->name[strlen(d)] == ' '))
  332.                     return ;
  333.             previous_device = current_device ;
  334.             current_device = current_device->next_hdr ;
  335.         }
  336.  
  337. /*
  338. * If no match, set the current device to NULL and return
  339. */
  340.  
  341.         current_device = NULL ;
  342.         return ;
  343.     }
  344.  
  345. /*
  346. * A colon was found in the second character position of the device
  347. * name, check for a valid block device.
  348. */
  349.  
  350.     else
  351.         is_disk = 1 ; /* set a flag to signify a disk device */
  352.  
  353.     if(strlen(d) > 2)    /* length must be less than or equal to 2 */
  354.         return ;
  355.  
  356. /*
  357. * Get the disk DPB for the drive specified.
  358. * If the disk doesn't exist, the current_dpb pointer will be
  359. * set to NULL, print a message and exit if this is the case.
  360. */
  361.  
  362.     if((current_dpb = disk_dpb(d[0] - 0x40)) == NULL)
  363.         no_disk_dpb() ;
  364.     current_device = current_dpb->dda ;
  365.     previous_device = NULL ;
  366.     return ;
  367. }        
  368.  
  369. /*
  370. * Function: print_device_columns()
  371. *
  372. * This function prints the headings and columns when listing
  373. * all device drivers.
  374. */
  375.  
  376. print_device_columns()
  377. {
  378.     printf("Base Address\t\t\tType\t\t\tName/Units\n") ;
  379.     printf("------------\t\t\t----\t\t\t----------\n") ;
  380. }
  381.  
  382. /*
  383. * Function: print_device_info()
  384. *
  385. * This function prints detailed information for a specific device.
  386. */
  387.  
  388. print_device_info(device)
  389. struct DEV_HDR far *device ;
  390. {
  391.     char device_string[9] ;
  392.     int i ;
  393.     printf("%04X:%04X\t\t\t",FP_SEG(device),FP_OFF(device)) ; /* print base address */
  394.     if(device->attribute & CHARACTER_DEVICE)
  395.     {
  396.         ++character_drivers ;
  397.         for(i = 0 ; i < 8 ; i++)
  398.             device_string[i] = device->name[i] ; /* copy it into local data segment */
  399.         device_string[8] = 0 ;
  400.         printf("Char\t\t\t%s\n",device_string) ; /* print "Char" and name */
  401.     }
  402.     else
  403.     {
  404.         ++block_drivers ;
  405.         printf("Block\t\t\t%u units\n",(int) device->name[0]) ;/* block dev.*/
  406.     }
  407. }
  408.  
  409. /*
  410. *
  411. * Function: disk_dpb()
  412. *
  413. * Return the address of the Disk Parameter Block (DPB) for the
  414. * drive specified. This DOS function is undocumented in current
  415. * DOS documentation. 
  416. */
  417.  
  418. struct DPB far *disk_dpb(drive)
  419. int drive ;
  420. {
  421.     char far *dsk_dpb ;
  422.  
  423.     ir.x.ax = 0x3200 ; /* Function call 32H */
  424.     ir.h.dl = drive ;
  425.     intdosx(&ir,&or,&sr) ;
  426.     if(++or.h.al == 0)
  427.         return (char far *) NULL ;
  428.     FP_SEG(dsk_dpb) = sr.ds ;
  429.     FP_OFF(dsk_dpb) = or.x.bx ;
  430.     return (struct DPB far *) dsk_dpb ;
  431. }
  432.  
  433. /*
  434. * Function: device_chain()
  435. *
  436. * Return the address of the first device in the device
  437. * chain.
  438. */
  439.  
  440.  
  441. struct DEV_HDR far *device_chain()
  442. {
  443.     struct DEV_HDR far *dev_chain ;
  444.     auto char far *search_ptr = (char far *) 0x00600000 ; /* start search at 0060:0000 */
  445.     static char *nuldev = "NUL     " ;
  446.     unsigned int x,i ;
  447.  
  448.     for(x = 0, i = 0 ; x < 65535 ; x++)
  449.     {
  450.         if(*search_ptr == *nuldev)    /* if first character matches, check others*/
  451.         {
  452.             for(i = 0 ; i <  8  ; i++)
  453.             {
  454.                 if(*(search_ptr + i) != nuldev[i])
  455.                     break ;
  456.             }
  457.             if(i == 8)      /* if i = 8 then the NUL device has been found */
  458.                 break ;
  459.         }
  460.         search_ptr++ ;
  461.     }
  462.     if(x == 0)
  463.         return NULL ;
  464.  
  465.     search_ptr -=  10 ; /* get to device header  */
  466.     return (struct DEV_HDR far *) search_ptr ;
  467. }
  468.  
  469. /*
  470. *
  471. * Function: no_device_chain()
  472. *
  473. * Print message "Can't find device chain" and exit
  474. */
  475.  
  476. no_device_chain()
  477. {
  478.     fprintf(stderr,"Can't find device chain\n") ;
  479.     exit(1) ;
  480. }
  481.  
  482. /*
  483. *
  484. * Function: no_disk_dpb()
  485. *
  486. * Print  message "Can't get DPB - Possible invalid drive\n" and exit
  487. */
  488.  
  489. no_disk_dpb()
  490. {
  491.     fprintf(stderr,"Can't get DPB - Possible invalid drive\n") ;
  492.     exit(1) ;
  493. }
  494.